home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / tiff / tif_open.c < prev    next >
C/C++ Source or Header  |  1995-06-21  |  9KB  |  373 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_open.c,v 1.47 1994/09/17 23:22:37 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994 Sam Leffler
  5.  * Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * TIFF Library.
  29.  */
  30. #include "tiffiop.h"
  31.  
  32. static const long typemask[13] = {
  33.     0L,        /* TIFF_NOTYPE */
  34.     0x000000ffL,    /* TIFF_BYTE */
  35.     0xffffffffL,    /* TIFF_ASCII */
  36.     0x0000ffffL,    /* TIFF_SHORT */
  37.     0xffffffffL,    /* TIFF_LONG */
  38.     0xffffffffL,    /* TIFF_RATIONAL */
  39.     0x000000ffL,    /* TIFF_SBYTE */
  40.     0x000000ffL,    /* TIFF_UNDEFINED */
  41.     0x0000ffffL,    /* TIFF_SSHORT */
  42.     0xffffffffL,    /* TIFF_SLONG */
  43.     0xffffffffL,    /* TIFF_SRATIONAL */
  44.     0xffffffffL,    /* TIFF_FLOAT */
  45.     0xffffffffL,    /* TIFF_DOUBLE */
  46. };
  47. static const int bigTypeshift[13] = {
  48.     0,        /* TIFF_NOTYPE */
  49.     24,        /* TIFF_BYTE */
  50.     0,        /* TIFF_ASCII */
  51.     16,        /* TIFF_SHORT */
  52.     0,        /* TIFF_LONG */
  53.     0,        /* TIFF_RATIONAL */
  54.     16,        /* TIFF_SBYTE */
  55.     16,        /* TIFF_UNDEFINED */
  56.     24,        /* TIFF_SSHORT */
  57.     0,        /* TIFF_SLONG */
  58.     0,        /* TIFF_SRATIONAL */
  59.     0,        /* TIFF_FLOAT */
  60.     0,        /* TIFF_DOUBLE */
  61. };
  62. static const int litTypeshift[13] = {
  63.     0,        /* TIFF_NOTYPE */
  64.     0,        /* TIFF_BYTE */
  65.     0,        /* TIFF_ASCII */
  66.     0,        /* TIFF_SHORT */
  67.     0,        /* TIFF_LONG */
  68.     0,        /* TIFF_RATIONAL */
  69.     0,        /* TIFF_SBYTE */
  70.     0,        /* TIFF_UNDEFINED */
  71.     0,        /* TIFF_SSHORT */
  72.     0,        /* TIFF_SLONG */
  73.     0,        /* TIFF_SRATIONAL */
  74.     0,        /* TIFF_FLOAT */
  75.     0,        /* TIFF_DOUBLE */
  76. };
  77.  
  78. /*
  79.  * Initialize the bit fill order, the
  80.  * shift & mask tables, and the byte
  81.  * swapping state according to the file
  82.  * contents and the machine architecture.
  83.  */
  84. static void
  85. TIFFInitOrder(register TIFF* tif, int magic, int bigendian)
  86. {
  87.     /* XXX how can we deduce this dynamically? */
  88.     tif->tif_fillorder = FILLORDER_MSB2LSB;
  89.  
  90.     tif->tif_typemask = typemask;
  91.     if (magic == TIFF_BIGENDIAN) {
  92.         tif->tif_typeshift = bigTypeshift;
  93.         if (!bigendian)
  94.             tif->tif_flags |= TIFF_SWAB;
  95.     } else {
  96.         tif->tif_typeshift = litTypeshift;
  97.         if (bigendian)
  98.             tif->tif_flags |= TIFF_SWAB;
  99.     }
  100. }
  101.  
  102. int
  103. _TIFFgetMode(const char* mode, const char* module)
  104. {
  105.     int m = -1;
  106.  
  107.     switch (mode[0]) {
  108.     case 'r':
  109.         m = O_RDONLY;
  110.         if (mode[1] == '+')
  111.             m = O_RDWR;
  112.         break;
  113.     case 'w':
  114.     case 'a':
  115.         m = O_RDWR|O_CREAT;
  116.         if (mode[0] == 'w')
  117.             m |= O_TRUNC;
  118.         break;
  119.     default:
  120.         TIFFError(module, "\"%s\": Bad mode", mode);
  121.         break;
  122.     }
  123.     return (m);
  124. }
  125.  
  126. TIFF*
  127. TIFFClientOpen(
  128.     const char* name, const char* mode,
  129.     thandle_t clientdata,
  130.     TIFFReadWriteProc readproc,
  131.     TIFFReadWriteProc writeproc,
  132.     TIFFSeekProc seekproc,
  133.     TIFFCloseProc closeproc,
  134.     TIFFSizeProc sizeproc,
  135.     TIFFMapFileProc mapproc,
  136.     TIFFUnmapFileProc unmapproc
  137. )
  138. {
  139.     static const char module[] = "TIFFClientOpen";
  140.     TIFF *tif;
  141.     int m, bigendian;
  142.  
  143.     m = _TIFFgetMode(mode, module);
  144.     if (m == -1)
  145.         goto bad2;
  146.     tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
  147.     if (tif == NULL) {
  148.         TIFFError(module, "%s: Out of memory (TIFF structure)", name);
  149.         goto bad2;
  150.     }
  151.     _TIFFmemset(tif, 0, sizeof (*tif));
  152.     tif->tif_name = (char *)tif + sizeof (TIFF);
  153.     strcpy(tif->tif_name, name);
  154.     tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
  155.     tif->tif_curdir = (tdir_t) -1;        /* non-existent directory */
  156.     tif->tif_curoff = 0;
  157.     tif->tif_curstrip = (tstrip_t) -1;    /* invalid strip */
  158.     tif->tif_row = (uint32)-1;        /* read/write pre-increment */
  159.     tif->tif_clientdata = clientdata;
  160.     tif->tif_readproc = readproc;
  161.     tif->tif_writeproc = writeproc;
  162.     tif->tif_seekproc = seekproc;
  163.     tif->tif_closeproc = closeproc;
  164.     tif->tif_sizeproc = sizeproc;
  165.     tif->tif_mapproc = mapproc;
  166.     tif->tif_unmapproc = unmapproc;
  167.  
  168.     { int one = 1; char* cp = (char*)&one; bigendian = (*cp == 0); }
  169.     /*
  170.      * Read in TIFF header.
  171.      */
  172.     if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
  173.         if (tif->tif_mode == O_RDONLY) {
  174.             TIFFError(name, "Cannot read TIFF header");
  175.             goto bad;
  176.         }
  177.         /*
  178.          * Setup header and write.
  179.          */
  180.         tif->tif_header.tiff_magic =  bigendian ?
  181.             TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
  182.         tif->tif_header.tiff_version = TIFF_VERSION;
  183.         tif->tif_header.tiff_diroff = 0;    /* filled in later */
  184.         if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
  185.             TIFFError(name, "Error writing TIFF header");
  186.             goto bad;
  187.         }
  188.         /*
  189.          * Setup the byte order handling.
  190.          */
  191.         TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
  192.         /*
  193.          * Setup default directory.
  194.          */
  195.         if (!TIFFDefaultDirectory(tif))
  196.             goto bad;
  197.         tif->tif_diroff = 0;
  198.         return (tif);
  199.     }
  200.     /*
  201.      * Setup the byte order handling.
  202.      */
  203.     if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
  204.         tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) {
  205.         TIFFError(name,  "Not a TIFF file, bad magic number %d (0x%x)",
  206.             tif->tif_header.tiff_magic,
  207.             tif->tif_header.tiff_magic);
  208.         goto bad;
  209.     }
  210.     TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
  211.     /*
  212.      * Swap header if required.
  213.      */
  214.     if (tif->tif_flags & TIFF_SWAB) {
  215.         TIFFSwabShort(&tif->tif_header.tiff_version);
  216.         TIFFSwabLong(&tif->tif_header.tiff_diroff);
  217.     }
  218.     /*
  219.      * Now check version (if needed, it's been byte-swapped).
  220.      * Note that this isn't actually a version number, it's a
  221.      * magic number that doesn't change (stupid).
  222.      */
  223.     if (tif->tif_header.tiff_version != TIFF_VERSION) {
  224.         TIFFError(name,
  225.             "Not a TIFF file, bad version number %d (0x%x)",
  226.             tif->tif_header.tiff_version,
  227.             tif->tif_header.tiff_version); 
  228.         goto bad;
  229.     }
  230.     tif->tif_flags |= TIFF_MYBUFFER;
  231.     tif->tif_rawcp = tif->tif_rawdata = 0;
  232.     tif->tif_rawdatasize = 0;
  233.     /*
  234.      * Setup initial directory.
  235.      */
  236.     switch (mode[0]) {
  237.     case 'r':
  238.         tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
  239.         if (TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
  240.             tif->tif_flags |= TIFF_MAPPED;
  241.         if (TIFFReadDirectory(tif)) {
  242.             tif->tif_rawcc = -1;
  243.             tif->tif_flags |= TIFF_BUFFERSETUP;
  244.             return (tif);
  245.         }
  246.         break;
  247.     case 'a':
  248.         /*
  249.          * Don't append to file that has information
  250.          * byte swapped -- we will write data that is
  251.          * in the opposite order.
  252.          */
  253.         if (tif->tif_flags & TIFF_SWAB) {
  254.             TIFFError(name,
  255.         "Cannot append to file that has opposite byte ordering");
  256.             goto bad;
  257.         }
  258.         /*
  259.          * New directories are automatically append
  260.          * to the end of the directory chain when they
  261.          * are written out (see TIFFWriteDirectory).
  262.          */
  263.         if (!TIFFDefaultDirectory(tif))
  264.             goto bad;
  265.         return (tif);
  266.     }
  267. bad:
  268.     tif->tif_mode = O_RDONLY;    /* XXX avoid flush */
  269.     TIFFClose(tif);
  270.     return ((TIFF*)0);
  271. bad2:
  272.     (void) (*closeproc)(clientdata);
  273.     return ((TIFF*)0);
  274. }
  275.  
  276. tsize_t
  277. TIFFScanlineSize(TIFF* tif)
  278. {
  279.     TIFFDirectory *td = &tif->tif_dir;
  280.     tsize_t scanline;
  281.     
  282.     scanline = td->td_bitspersample * td->td_imagewidth;
  283.     if (td->td_planarconfig == PLANARCONFIG_CONTIG)
  284.         scanline *= td->td_samplesperpixel;
  285.     return (howmany(scanline, 8));
  286. }
  287.  
  288. /*
  289.  * Query functions to access private data.
  290.  */
  291.  
  292. /*
  293.  * Return open file's name.
  294.  */
  295. const char *
  296. TIFFFileName(TIFF* tif)
  297. {
  298.     return (tif->tif_name);
  299. }
  300.  
  301. /*
  302.  * Return open file's I/O descriptor.
  303.  */
  304. int
  305. TIFFFileno(TIFF* tif)
  306. {
  307.     return (tif->tif_fd);
  308. }
  309.  
  310. /*
  311.  * Return read/write mode.
  312.  */
  313. int
  314. TIFFGetMode(TIFF* tif)
  315. {
  316.     return (tif->tif_mode);
  317. }
  318.  
  319. /*
  320.  * Return nonzero if file is organized in
  321.  * tiles; zero if organized as strips.
  322.  */
  323. int
  324. TIFFIsTiled(TIFF* tif)
  325. {
  326.     return (isTiled(tif));
  327. }
  328.  
  329. /*
  330.  * Return current row being read/written.
  331.  */
  332. uint32
  333. TIFFCurrentRow(TIFF* tif)
  334. {
  335.     return (tif->tif_row);
  336. }
  337.  
  338. /*
  339.  * Return index of the current directory.
  340.  */
  341. tdir_t
  342. TIFFCurrentDirectory(TIFF* tif)
  343. {
  344.     return (tif->tif_curdir);
  345. }
  346.  
  347. /*
  348.  * Return current strip.
  349.  */
  350. tstrip_t
  351. TIFFCurrentStrip(TIFF* tif)
  352. {
  353.     return (tif->tif_curstrip);
  354. }
  355.  
  356. /*
  357.  * Return current tile.
  358.  */
  359. ttile_t
  360. TIFFCurrentTile(TIFF* tif)
  361. {
  362.     return (tif->tif_curtile);
  363. }
  364.  
  365. /*
  366.  * Return nonzero if the file has byte-swapped data.
  367.  */
  368. int
  369. TIFFIsByteSwapped(TIFF* tif)
  370. {
  371.     return ((tif->tif_flags & TIFF_SWAB) != 0);
  372. }
  373.